// api/points.js - 积分相关接口
import request from './request.js';

/**
 * 积分相关API
 */
export const pointsApi = {
  /**
   * 获取用户积分
   * @returns {Promise}
   */
  async getUserPoints() {
    try {
      // 实际项目中，这里应该调用后端API
      // const res = await request.get('/points/user');
      // return res;
      
      // 模拟数据返回
      return {
        code: 1,
        msg: 'success',
        data: {
          points: Math.floor(Math.random() * 1000) + 100 // 随机积分，实际应该从后端获取
        }
      };
    } catch (error) {
      console.error('获取用户积分失败:', error);
      // 返回模拟数据，确保前端功能正常运行
      return {
        code: 1,
        msg: 'success',
        data: {
          points: 0
        }
      };
    }
  },

  /**
   * 添加积分
   * @param {Object} data - 积分数据
   * @param {number} data.points - 积分数量
   * @param {string} data.source - 积分来源（如 video_watch, task_completed 等）
   * @param {string} data.relatedId - 关联ID（可选，如视频ID、任务ID）
   * @returns {Promise}
   */
  async addPoints(data) {
    try {
      // 实际项目中，这里应该调用后端API
      // const res = await request.post('/points/add', data);
      // return res;
      
      // 模拟数据返回
      return {
        code: 1,
        msg: '积分添加成功',
        data: {
          newPoints: Math.floor(Math.random() * 1000) + 100 + data.points, // 新的总积分
          addedPoints: data.points, // 本次添加的积分
          source: data.source
        }
      };
    } catch (error) {
      console.error('添加积分失败:', error);
      // 返回错误信息
      return {
        code: 0,
        msg: '添加积分失败，请稍后重试',
        data: null
      };
    }
  },

  /**
   * 消耗积分
   * @param {Object} data - 积分消耗数据
   * @param {number} data.points - 消耗的积分数量
   * @param {string} data.usage - 积分用途
   * @returns {Promise}
   */
  async consumePoints(data) {
    try {
      // 实际项目中，这里应该调用后端API
      // const res = await request.post('/points/consume', data);
      // return res;
      
      // 模拟数据返回
      return {
        code: 1,
        msg: '积分消耗成功',
        data: {
          newPoints: Math.floor(Math.random() * 1000), // 新的总积分
          consumedPoints: data.points, // 本次消耗的积分
          usage: data.usage
        }
      };
    } catch (error) {
      console.error('消耗积分失败:', error);
      throw error;
    }
  },

  /**
   * 获取积分记录
   * @param {Object} params - 查询参数
   * @param {number} params.page - 页码
   * @param {number} params.limit - 每页数量
   * @param {string} params.type - 类型（income/expense/all）
   * @param {string} params.source - 来源（可选）
   * @returns {Promise}
   */
  async getPointsRecords(params = {}) {
    try {
      // 实际项目中，这里应该调用后端API
      // const res = await request.get('/points/records', { params });
      // return res;
      
      // 模拟数据返回
      const mockRecords = [
        {
          id: '1',
          points: 5,
          type: 'income',
          source: 'video_watch',
          sourceText: '观看视频',
          description: '观看视频获得积分奖励',
          createTime: new Date(Date.now() - 3600000).toISOString(), // 1小时前
          relatedId: 'video1'
        },
        {
          id: '2',
          points: 10,
          type: 'income',
          source: 'task_completed',
          sourceText: '完成任务',
          description: '完成新手任务',
          createTime: new Date(Date.now() - 7200000).toISOString(), // 2小时前
          relatedId: 'task1'
        },
        {
          id: '3',
          points: 20,
          type: 'income',
          source: 'sign_in',
          sourceText: '每日签到',
          description: '连续签到第3天',
          createTime: new Date(Date.now() - 86400000).toISOString(), // 1天前
          relatedId: ''
        }
      ];
      
      // 根据类型筛选
      let filteredRecords = mockRecords;
      if (params.type && params.type !== 'all') {
        filteredRecords = mockRecords.filter(record => record.type === params.type);
      }
      
      // 根据来源筛选
      if (params.source) {
        filteredRecords = filteredRecords.filter(record => record.source === params.source);
      }
      
      return {
        code: 1,
        msg: 'success',
        data: {
          list: filteredRecords,
          total: filteredRecords.length,
          page: params.page || 1,
          limit: params.limit || 10
        }
      };
    } catch (error) {
      console.error('获取积分记录失败:', error);
      // 返回空数据，确保前端功能正常运行
      return {
        code: 1,
        msg: 'success',
        data: {
          list: [],
          total: 0,
          page: 1,
          limit: 10
        }
      };
    }
  },

  /**
   * 获取积分规则
   * @returns {Promise}
   */
  async getPointsRules() {
    try {
      // 实际项目中，这里应该调用后端API
      // const res = await request.get('/points/rules');
      // return res;
      
      // 模拟数据返回
      return {
        code: 1,
        msg: 'success',
        data: [
          {
            type: 'video_watch',
            name: '观看视频',
            points: 5,
            desc: '观看视频15秒可获得5积分',
            limitPerDay: 20
          },
          {
            type: 'video_watch_double',
            name: '观看激励视频',
            points: 10,
            desc: '观看激励视频可获得10积分',
            limitPerDay: 10
          },
          {
            type: 'task_completed',
            name: '完成任务',
            points: 10,
            desc: '完成任务可获得相应积分',
            limitPerDay: 0 // 0表示无限制
          }
        ]
      };
    } catch (error) {
      console.error('获取积分规则失败:', error);
      throw error;
    }
  },

  /**
   * 兑换积分奖励
   * @param {Object} data - 兑换数据
   * @param {string} data.rewardId - 奖励ID
   * @returns {Promise}
   */
  async exchangeReward(data) {
    try {
      // 实际项目中，这里应该调用后端API
      // const res = await request.post('/points/exchange', data);
      // return res;
      
      // 模拟数据返回
      return {
        code: 1,
        msg: '兑换成功',
        data: {
          rewardId: data.rewardId,
          rewardName: '示例奖励',
          pointsConsumed: 100,
          newPoints: 500
        }
      };
    } catch (error) {
      console.error('兑换奖励失败:', error);
      throw error;
    }
  }
};

// 导出默认对象
export default pointsApi;

// 导出单独的函数，方便使用
export const getUserPoints = pointsApi.getUserPoints;
export const addPoints = pointsApi.addPoints;
export const consumePoints = pointsApi.consumePoints;
export const getPointsRecords = pointsApi.getPointsRecords;
export const getPointsRules = pointsApi.getPointsRules;
export const exchangeReward = pointsApi.exchangeReward;